home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_11_01 / 1101075b < prev    next >
Encoding:
Text File  |  1992-11-01  |  10.3 KB  |  401 lines
  1. /*****************************************************
  2.            File Name: STR_EDIT.C
  3.          Description: Library of functions for editing
  4.                       strings
  5. Global Function List: str_center
  6.                       str_delete
  7.                       str_insert
  8.                       str_ljust
  9.                       str_ltrim
  10.                       str_mrplc
  11.                       str_ocat
  12.                       str_repeat
  13.                       str_rjust
  14.                       str_rplc
  15.                       str_rtrim
  16.                       str_trim
  17.                       str_vcat
  18.          Portability: Standard C
  19. ******************************************************/
  20.  
  21. /* Standard C */
  22. #include <stdarg.h>
  23. #include <stdlib.h>
  24. #include <string.h>
  25.  
  26. /* Own */
  27. #include <str_edit.h>
  28.  
  29. /*****************************************************
  30.          Name: str_center
  31.    Parameters: Str - string to center
  32.                Len - num of chars of centered string
  33.        Return: Str
  34.   Description: Centers a string in a desired length
  35.                by removing tabs and adding spaces
  36.                to both sides of string.
  37. *****************************************************/
  38. char *str_center( char *Str, size_t Len )
  39.    {
  40.  
  41.    size_t LenOrg;
  42.  
  43.    /* Trim spaces and tabs off the string */ 
  44.    str_trim( Str, " \t" );
  45.  
  46.    LenOrg = strlen( Str );
  47.    if ( Len <= LenOrg )
  48.       {
  49.       /* The desired string length is shorter than
  50.       ** the original so return */
  51.       return ( Str );
  52.       }
  53.  
  54.    /* Add the spaces to each side */
  55.    str_rjust( Str, ( LenOrg + Len ) / 2 );
  56.    str_ljust( Str, Len  );
  57.  
  58.    return ( Str );
  59.  
  60.    }   /* function str_center */
  61.  
  62.  
  63. /*****************************************************
  64.          Name: str_delete
  65.    Parameters: Str - string to edit
  66.                Pos - index to start deleting chars at
  67.                Num - number of charcters to delete
  68.        Return: Str
  69.   Description: Modifies Str, by deleting Num chars
  70.                beginning at Pos.
  71. *****************************************************/
  72. char *str_delete( char *Str, char *Pos, size_t Num )
  73.    {
  74.  
  75.    size_t Len = strlen( Str );
  76.  
  77.    if ( ( Pos >= &Str[Len] ) || ( Num == 0 ) )
  78.       {
  79.       /* Outside string or no chars to delete */
  80.       return ( Str );
  81.       }
  82.  
  83.    Num = min( Num, strlen( Pos ) );
  84.    if ( Num )
  85.       {
  86.       /* Delete characters by contactenating */
  87.       memmove( Pos, &Pos[Num],
  88.             strlen( &Pos[Num] ) + 1 );
  89.       }
  90.  
  91.    return ( Str );
  92.  
  93.    }   /* function str_delete */
  94.  
  95.  
  96. /*****************************************************
  97.          Name: str_insert
  98.    Parameters: Str - string to edit
  99.                Pos - pointer to location withing Str
  100.                Insrt - string to insert into Str
  101.        Return: Str
  102.   Description: Inserts a string Insrt into Str at Pos
  103. *****************************************************/
  104. char *str_insert( char *Str, char *Pos, char *Insrt )
  105.    {
  106.  
  107.    size_t Len = strlen( Insrt );
  108.    char *Tmp   = &Pos[Len];
  109.  
  110.    memmove( Tmp, Pos, strlen( Pos ) + 1 );
  111.    memmove( Pos, Insrt, Len );
  112.  
  113.    return ( Str );
  114.  
  115.    }   /* function str_insert */
  116.  
  117.  
  118. /*****************************************************
  119.          Name: str_ljust
  120.    Parameters: Str - string to left justify
  121.                Len - length of string
  122.        Return: Str
  123.   Description: Pads right end of Str with spaces to
  124.                left justify Str to a new length Len.
  125. *****************************************************/
  126. char *str_ljust( char *Str, size_t Len )
  127.    {
  128.  
  129.    size_t LenOrg = strlen( Str );
  130.    char *StrEnd = &Str[LenOrg];
  131.  
  132.    Len = max( Len, LenOrg ) - LenOrg;
  133.    StrEnd[Len] = '\0';
  134.  
  135.    while ( Len )
  136.       {
  137.       Len--;
  138.       StrEnd[Len] = ' ';
  139.       }
  140.  
  141.    return ( Str );
  142.  
  143.    }   /* function str_ljust */
  144.  
  145.  
  146. /*****************************************************
  147.          Name: str_ltrim
  148.    Parameters: Str - string to trim
  149.                Trim - string containing chars to trim
  150.        Return: Str
  151.   Description: Delete characters from the left end of
  152.                Str that are contained in Trim
  153. *****************************************************/
  154. char *str_ltrim( char *Str, char *Trim )
  155.    {
  156.  
  157.    size_t Num = strspn( Str, Trim );
  158.  
  159.    str_delete( Str, Str, Num );
  160.  
  161.    return ( Str );
  162.  
  163.    }   /* function str_ltrim */
  164.  
  165.  
  166. /*****************************************************
  167.          Name: str_mrplc
  168. Expanded Name: String Multiple Search and Replace
  169.    Parameters: Str - string to edit
  170.                Find - search string
  171.                Rplc - replacement string
  172.        Return: Str
  173.   Description: Multiple search and replace.  All
  174.                occurrences of Find within Str are
  175.                replaced with Rplc.
  176. *****************************************************/
  177. char *str_mrplc( char *Str, char *Find, char *Rplc )
  178.    {
  179.  
  180.    char *StrWork = Str;
  181.    size_t LenRplc = strlen( Rplc );
  182.  
  183.    while ( ( StrWork =
  184.          strstr( StrWork, Find ) ) != NULL )
  185.       {
  186.       str_delete( Str, StrWork, strlen( Find ) );
  187.       str_insert( Str, StrWork, Rplc );
  188.       StrWork += LenRplc;
  189.       }
  190.  
  191.    return ( Str );
  192.  
  193.    }   /* function str_mrplc */
  194.  
  195.  
  196. /*****************************************************
  197.          Name: str_ocat
  198. Expanded Name: Concatenate overlapped strings
  199.    Parameters: Dest - destination string
  200.                Str - string to concat
  201.        Return: Dest
  202.   Description: Behaves the same as strcat in string.h.
  203.                This version will work for strings that
  204.                overlap in memory.
  205. *****************************************************/
  206. char *str_ocat( char *Dest, char *Str )
  207.    {
  208.  
  209.    return ( (char *)memmove(
  210.          (void *)&Dest[strlen( Dest )],
  211.          (void *)Str, strlen( Str ) + 1 ) );
  212.  
  213.    }   /* function str_ocat */
  214.  
  215.  
  216. /*****************************************************
  217.          Name: str_repeat
  218.    Parameters: Str - string buffer to load
  219.                Rpt - repition string
  220.                Num - number of repitions
  221.        Return: Str
  222.   Description: Builds a string of length Num, by
  223.                repeating a substring Rpt.
  224. *****************************************************/
  225. char *str_repeat( char *Str, char *Rpt, size_t Num )
  226.    {
  227.  
  228.    size_t Len = strlen( Rpt );
  229.  
  230.    if ( Len == 1 )
  231.       {
  232.       /* The string is only one character */
  233.       memset( Str, *Rpt, Num );
  234.       }
  235.    else
  236.       {
  237.  
  238.       size_t i, j;
  239.  
  240.       /* Build Str with repitions of Rpt */
  241.       for ( i = 0, j = 0; i < Num; i++ )
  242.          {
  243.          Str[i] = Rpt[j++];
  244.          j %= Len;
  245.          }   /* for i */
  246.  
  247.       }   /* else */
  248.  
  249.    Str[Num] = '\0';
  250.  
  251.    return ( Str );
  252.  
  253.    }   /* function str_repeat */
  254.  
  255.  
  256. /*****************************************************
  257.          Name: str_rplc
  258. Expanded Name: String Search and Replace
  259.    Parameters: Str - string to edit
  260.                Find - search string
  261.                Rplc - replacement string
  262.        Return: Str
  263.   Description: Search and replace.  First
  264.                occurrences of Find within Str is
  265.                replaced with Rplc.
  266. *****************************************************/
  267. char *str_rplc( char *Str, char *Find, char *Rplc )
  268.    {
  269.  
  270.    char *StrWork = strstr( Str, Find );
  271.  
  272.    if ( StrWork )
  273.       {
  274.       str_delete( Str, StrWork, strlen( Find ) );
  275.       str_insert( Str, StrWork, Rplc );
  276.       }
  277.  
  278.    return ( Str );
  279.  
  280.    }   /* function str_rplc */
  281.  
  282.  
  283. /*****************************************************
  284.          Name: str_rjust
  285. Expanded Name: String Right Justify
  286.    Parameters: Str - string to edit
  287.                Len - new length of string
  288.        Return: Str
  289.   Description: Pads the left end of string so that it
  290.                is right justified to a total length of
  291.                Len.
  292. *****************************************************/
  293. char *str_rjust( char *Str, size_t Len )
  294.    {
  295.  
  296.    size_t LenOrg = strlen( Str );
  297.  
  298.    Len = max( LenOrg, Len ) - LenOrg;
  299.  
  300.    if ( Len )
  301.       {
  302.       memmove( &Str[Len], Str, LenOrg + 1 );
  303.       while ( Len )
  304.          {
  305.          Len--;
  306.          Str[Len] = ' ';
  307.          }
  308.       }
  309.  
  310.    return ( Str );
  311.  
  312.    }   /* function str_rjust */
  313.  
  314.  
  315. /*****************************************************
  316.          Name: str_rtrim
  317.    Parameters: Str - string to trim
  318.                Trim - string of characters to trim
  319.        Return: Str
  320.   Description: Delete characters from the right end
  321.                of Str that are contained in Trim
  322. *****************************************************/
  323. char *str_rtrim( char *Str, char *Trim )
  324.    {
  325.  
  326.    char *StrWork = &Str[strlen( Str ) - 1];
  327.  
  328.    /* Look for last character in string not being
  329.    ** in trim string */
  330.    while ( ( Str != StrWork ) &&
  331.          ( strspn( StrWork, Trim ) != 0 ) )
  332.       {
  333.       *StrWork-- = '\0';
  334.       }
  335.  
  336.    return ( Str );
  337.  
  338.    }   /* function str_rtrim */
  339.  
  340.  
  341. /*****************************************************
  342.          Name: str_trim
  343.    Parameters: Str - string to trim
  344.                Trim - string of characters to trim
  345.        Return: Str
  346.   Description: Delete characters from both ends of Str
  347. *****************************************************/
  348. char *str_trim( char *Str, char *Trim )
  349.    {
  350.  
  351.    str_ltrim( Str, Trim );
  352.    str_rtrim( Str, Trim );
  353.  
  354.    return ( Str );
  355.  
  356.    }   /* function str_trim */
  357.  
  358. /*****************************************************
  359.          Name: str_vcat
  360.    Parameters: Dest - destination string
  361.                Str1 - required first string
  362.        Return: Dest
  363.   Description: Variable argument version of strcat.
  364.                Concatenates a list of strings into
  365.                a destination string.  The last
  366.                argument must be a NULL pointer.
  367. *****************************************************/
  368. char *str_vcat( char *Dest, char *Str1, ... )
  369.    {
  370.  
  371.    va_list VarArgList;
  372.    char *Str;
  373.  
  374.    /* Initialize variable arguments */
  375.    va_start( VarArgList, Dest );
  376.  
  377.    /* Get first var arg string */
  378.    Str = va_arg( VarArgList, char * );
  379.  
  380.    strcat( Dest, Str1 );
  381.    while ( Str != NULL )
  382.       {
  383.  
  384.       /* Loop though all the arguments */
  385.       strcat( Dest, Str );
  386.  
  387.       /* Get the next string */
  388.       Str = va_arg( VarArgList, char * );
  389.  
  390.       }
  391.  
  392.    /* Clean up */
  393.    va_end( VarArgList );
  394.  
  395.    return ( Dest );
  396.  
  397.    } /* function str_vcat */
  398.  
  399. /* End of File */
  400.  
  401.